```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Zuul与Gateway比较 | 技术小馆</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: #111;
        }
        .hero {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
        }
        .card {
            transition: transform 0.3s ease, box-shadow 0.3s ease;
        }
        .card:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .code-block {
            background-color: #2d2d2d;
            border-radius: 6px;
            padding: 1rem;
            color: #f8f8f2;
            font-family: 'Courier New', Courier, monospace;
            overflow-x: auto;
        }
        .comparison-table {
            width: 100%;
            border-collapse: collapse;
        }
        .comparison-table th {
            background-color: #f3f4f6;
            padding: 12px 16px;
            text-align: left;
            font-weight: 600;
        }
        .comparison-table td {
            padding: 12px 16px;
            border-bottom: 1px solid #e5e7eb;
        }
        .comparison-table tr:nth-child(even) td {
            background-color: #f9fafb;
        }
        .icon-circle {
            width: 50px;
            height: 50px;
            border-radius: 50%;
            display: flex;
            align-items: center;
            justify-content: center;
            font-size: 1.5rem;
            margin-right: 1rem;
        }
        .feature-item {
            display: flex;
            align-items: flex-start;
            margin-bottom: 1.5rem;
        }
        .feature-content {
            flex: 1;
        }
        .filter-type {
            border-left: 4px solid #4f46e5;
            padding-left: 1rem;
            margin: 1.5rem 0;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero text-white py-20">
        <div class="container mx-auto px-6 max-w-6xl">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-1/2 mb-10 md:mb-0">
                    <h1 class="text-4xl md:text-5xl font-bold mb-4">Zuul与Gateway深度对比</h1>
                    <p class="text-xl mb-8 opacity-90">探索微服务架构中两大API网关的异同与选择策略</p>
                    <div class="flex flex-wrap gap-4">
                        <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full">#微服务</span>
                        <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full">#API网关</span>
                        <span class="px-4 py-2 bg-white bg-opacity-20 rounded-full">#SpringCloud</span>
                    </div>
                </div>
                <div class="md:w-1/2">
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1718971992061-8857cc56-cb9d-4411-aa9c-f7991813fe95.png" alt="API Gateway Architecture" class="rounded-lg shadow-2xl w-full h-auto">
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <main class="container mx-auto px-6 max-w-6xl py-12">
        <!-- Introduction -->
        <section class="mb-16">
            <div class="prose max-w-none">
                <h2 class="text-3xl mb-6">API网关在微服务架构中的重要性</h2>
                <p>在微服务架构中，路由网关（API Gateway）作为系统的前端入口，扮演着至关重要的角色。它不仅负责将客户端的请求路由到相应的服务，还提供了一系列功能，如负载均衡、权限校验、日志记录和流量控制等。在这个领域，Zuul 和 Spring Cloud Gateway 是两种常用的网关解决方案。</p>
            </div>
        </section>

        <!-- Zuul Section -->
        <section class="mb-16">
            <div class="prose max-w-none">
                <h2 class="text-3xl mb-6 flex items-center">
                    <span class="icon-circle bg-blue-100 text-blue-600 mr-4"><i class="fas fa-network-wired"></i></span>
                    Netflix Zuul
                </h2>
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <h3 class="text-2xl mb-4">介绍</h3>
                        <p>Zuul是由Netflix开源的一款基于Java的API网关，专为微服务架构设计。作为微服务架构的核心组件之一，Zuul在系统入口处扮演着流量管理和控制的角色，通过路由、过滤和处理请求来简化微服务的开发和运维。</p>
                        <p>Zuul是一个基于Servlet编程模型的API网关，部署在系统的边缘，作为所有外部请求进入系统的入口。它的核心功能包括路由、过滤、监控、动态路由配置、负载均衡、安全认证等。Zuul通过这些功能实现对请求的控制和管理，从而保证系统的可靠性和安全性。</p>
                    </div>
                    <div>
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1718972066085-528cbaea-be4c-4e93-a0c6-1a4405ec6aed.png" alt="Zuul Architecture" class="rounded-lg shadow-md w-full h-auto">
                    </div>
                </div>
            </div>

            <!-- Programming Model -->
            <div class="prose max-w-none mt-12">
                <h3 class="text-2xl mb-4">编程模型</h3>
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <p>Zuul作为一个基于Java Servlet的应用程序，依赖于Servlet容器来处理所有的HTTP请求和响应。一般情况下，Zuul使用嵌入式的Servlet容器，如Embedded Tomcat，来运行。</p>
                        <ul class="space-y-2">
                            <li><strong>Servlet:</strong> Zuul的核心是一个基于Servlet的Web应用，它能够处理HTTP请求和响应。通过Servlet，Zuul能够与Java Web生态系统中的其他组件无缝集成。</li>
                            <li><strong>Filters（过滤器）:</strong> 这是Zuul最重要的组成部分。Zuul通过过滤器机制来实现各种功能。</li>
                            <li><strong>FilterProcessor:</strong> 负责管理和执行过滤器。FilterProcessor根据过滤器的类型和顺序，依次调用相应的过滤器进行处理。</li>
                            <li><strong>Ribbon:</strong> 作为客户端负载均衡器，Zuul通常与Netflix的Ribbon集成，以实现对后端服务的负载均衡。</li>
                        </ul>
                    </div>
                    <div>
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1718972156742-89e86acd-1640-457d-a159-b780d7fbaefc.png" alt="Zuul Programming Model" class="rounded-lg shadow-md w-full h-auto">
                    </div>
                </div>
            </div>

            <!-- Working Principle -->
            <div class="prose max-w-none mt-12">
                <h3 class="text-2xl mb-4">工作原理</h3>
                <p>Zuul的工作原理基于过滤器链模式。在收到一个请求时，Zuul会按顺序执行一系列过滤器，过滤器通过检查请求的内容和上下文信息，决定是否对请求进行处理或拦截。具体工作流程如下：</p>
                <ol class="list-decimal pl-6 space-y-2">
                    <li><strong>请求接收:</strong> Zuul作为系统的入口，接收所有的外部请求。</li>
                    <li><strong>Pre过滤器执行:</strong> 执行一组预处理过滤器，对请求进行身份验证、参数校验、日志记录等操作。</li>
                    <li><strong>Routing过滤器执行:</strong> 根据请求的路径或其他路由规则，将请求转发到具体的后端服务实例。</li>
                    <li><strong>Post过滤器执行:</strong> 对从后端服务返回的响应进行处理，如增加响应头、记录日志等。</li>
                    <li><strong>Error过滤器执行:</strong> 在请求处理过程中发生异常时，执行错误过滤器进行错误处理。</li>
                </ol>
            </div>

            <!-- Filters -->
            <div class="prose max-w-none mt-12">
                <h3 class="text-2xl mb-4">过滤器</h3>
                <p>Zuul的过滤器机制是其核心功能之一，它允许开发者在请求的不同生命周期中执行各种逻辑处理，例如身份验证、请求日志记录、路由、错误处理等。</p>
                
                <div class="filter-type">
                    <h4 class="text-xl mb-3">过滤器类型</h4>
                    <p>Zuul的过滤器可以分为四种类型，每种类型都在请求处理的不同阶段执行：</p>
                    <ul class="space-y-2">
                        <li><strong>Pre Filters (前置过滤器):</strong> 在请求被路由之前执行，通常用于身份验证、请求参数校验、日志记录等。如果发现请求不符合预期，可以直接返回响应或者重定向到其他路径。</li>
                        <li><strong>Routing Filters (路由过滤器):</strong> 用于将请求路由到服务实例，可以实现动态路由、负载均衡、重试等功能。</li>
                        <li><strong>Post Filters (后置过滤器):</strong> 在请求被路由之后执行，处理响应数据，可以修改响应内容、记录日志等。</li>
                        <li><strong>Error Filters (错误过滤器):</strong> 在处理请求过程中发生错误时执行，主要用于处理异常情况，返回适当的错误响应。</li>
                    </ul>
                </div>

                <div class="filter-type">
                    <h4 class="text-xl mb-3">过滤器执行顺序</h4>
                    <p>Zuul的过滤器按照以下顺序执行：</p>
                    <ul class="space-y-2">
                        <li><strong>Pre Filters:</strong> 在请求被路由之前执行。</li>
                        <li><strong>Routing Filters:</strong> 用于将请求路由到服务实例。</li>
                        <li><strong>Post Filters:</strong> 在请求被路由之后执行。</li>
                        <li><strong>Error Filters:</strong> 处理请求过程中发生的错误。</li>
                    </ul>
                </div>

                <div class="filter-type">
                    <h4 class="text-xl mb-3">自定义过滤器</h4>
                    <p>开发者可以通过编写自定义的Java类来实现不同类型的过滤器。每个过滤器需要继承Zuul提供的抽象类，并实现指定的方法。主要的抽象类包括：</p>
                    <ul class="space-y-2">
                        <li><strong>ZuulFilter：</strong> 所有过滤器需要继承的抽象类，定义了过滤器的基本行为和生命周期方法。</li>
                        <li><strong>ZuulPreFilter、ZuulRouteFilter、ZuulPostFilter、ZuulErrorFilter：</strong> 分别对应四种类型的过滤器，开发者根据需要选择合适的类型进行扩展。</li>
                    </ul>
                    <div class="code-block mt-4">
                        <pre><code>public class AuthFilter extends ZuulFilter {
    @Override
    public String filterType() {
        return "pre";
    }

    @Override
    public int filterOrder() {
        return 1;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        String authToken = request.getHeader("Authorization");

        if (authToken == null || !authToken.startsWith("Bearer ")) {
            ctx.setSendZuulResponse(false);
            ctx.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
            ctx.setResponseBody("Unauthorized");
            ctx.set("isAuthSuccess", false);
        } else {
            ctx.set("isAuthSuccess", true);
        }
        return null;
    }
}</code></pre>
                    </div>
                </div>
            </div>

            <!-- Routing & Load Balancing -->
            <div class="prose max-w-none mt-12">
                <h3 class="text-2xl mb-4">路由和负载均衡</h3>
                <p>Zuul通过路由功能将请求转发到后端的微服务实例。在Zuul中配置的路由规则决定了请求应该如何被路由到相应的服务实例。</p>
                
                <div class="filter-type">
                    <h4 class="text-xl mb-3">Zuul的路由功能</h4>
                    <p>Zuul支持多种路由方式：</p>
                    <ul class="space-y-2">
                        <li><strong>基于服务名称的路由：</strong> Zuul通过服务名称将请求路由到注册中心中的服务实例。</li>
                        <li><strong>基于URL的路由：</strong> 直接配置请求路径到服务实例的映射。</li>
                        <li><strong>通配符和正则表达式路由：</strong> 使用通配符和正则表达式匹配请求路径。</li>
                    </ul>
                    <div class="code-block mt-4">
                        <pre><code># application.yml
spring:
  application:
    name: zuul-gateway

zuul:
  routes:
    my-service:
      path: /my-service/**
      serviceId: my-service
      stripPrefix: false
      sensitiveHeaders: Cookie,Set-Cookie
      custom-key: custom-value
  ribbon:
    eureka:
      enabled: true
    listOfServers: http://server1:8080,http://server2:8080
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule</code></pre>
                    </div>
                </div>

                <div class="filter-type">
                    <h4 class="text-xl mb-3">Zuul的负载均衡策略</h4>
                    <p>Zuul支持多种负载均衡策略：</p>
                    <ul class="space-y-2">
                        <li><strong>默认的负载均衡策略：</strong> Zuul默认使用Ribbon作为负载均衡器，Ribbon提供了多种负载均衡算法（如轮询、随机、权重等）。</li>
                        <li><strong>手动指定负载均衡策略：</strong> 可以在Zuul的路由配置中手动指定负载均衡策略。</li>
                        <li><strong>自定义负载均衡策略：</strong> 可以自定义Ribbon的IRule实现来定义自己的负载均衡策略。</li>
                    </ul>
                </div>
            </div>

            <!-- Security -->
            <div class="prose max-w-none mt-12">
                <h3 class="text-2xl mb-4">安全性机制</h3>
                <p>Zuul作为Spring Cloud中的网关服务，承担着路由转发、负载均衡以及安全控制等重要功能，具有一些安全性机制来保护系统免受恶意攻击和非法访问。</p>
                
                <div class="grid md:grid-cols-2 gap-6 mt-6">
                    <div class="card bg-white p-6 rounded-lg shadow-md">
                        <div class="icon-circle bg-blue-100 text-blue-600 mb-4"><i class="fas fa-shield-alt"></i></div>
                        <h4 class="text-xl font-semibold mb-3">IP黑白名单</h4>
                        <p>可以配置Zuul拒绝或允许特定的IP地址访问。这种方式可以用来阻止未经授权的IP地址访问服务。</p>
                    </div>
                    <div class="card bg-white p-6 rounded-lg shadow-md">
                        <div class="icon-circle bg-purple-100 text-purple-600 mb-4"><i class="fas fa-lock"></i></div>
                        <h4 class="text-xl font-semibold mb-3">安全头信息过滤</h4>
                        <p>Zuul可以配置哪些HTTP头信息应该被移除或保留。这对于防止敏感信息泄露至下游服务非常重要。</p>
                    </div>
                    <div class="card bg-white p-6 rounded-lg shadow-md">
                        <div class="icon-circle bg-green-100 text-green-600 mb-4"><i class="fas fa-key"></i></div>
                        <h4 class="text-xl font-semibold mb-3">SSL终端保护</h4>
                        <p>Zuul支持将SSL终端保护与后端服务进行解耦，确保数据在传输过程中的安全性。</p>
                    </div>
                    <div class="card bg-white p-6 rounded-lg shadow-md">
                        <div class="icon-circle bg-red-100 text-red-600 mb-4"><i class="fas fa-user-shield"></i></div>
                        <h4 class="text-xl font-semibold mb-3">请求认证和授权</h4>
                        <p>Zuul可以集成OAuth、单点登录等认证和授权服务，确保只有授权的用户可以访问后端服务。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Gateway Section -->
        <section class="mb-16">
            <div class="prose max-w-none">
                <h2 class="text-3xl mb-6 flex items-center">
                    <span class="icon-circle bg-green-100 text-green-600 mr-4"><i class="fas fa-bolt"></i></span>
                    Spring Cloud Gateway
                </h2>
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <h3 class="text-2xl mb-4">介绍</h3>
                        <p>Spring Cloud Gateway是Spring Cloud生态系统中的一个全新的API网关服务，用于构建基于Spring Boot的微服务架构中的网关服务。它基于Reactor模式，使用Spring WebFlux框架，提供了一系列强大的功能和灵活的配置选项，使得它成为构建现代、高效、可扩展的微服务网关的首选。</p>
                    </div>
                    <div>
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1718972289771-ae2f8ebf-efc9-41cf-99ac-922dfe895d1c.png" alt="Spring Cloud Gateway Architecture" class="rounded-lg shadow-md w-full h-auto">
                    </div>
                </div>
            </div>

            <!-- Reactive Programming Model -->
            <div class="prose max-w-none mt-12">
                <h3 class="text-2xl mb-4">响应式编程模型</h3>
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <p>Spring Cloud Gateway的编程模型基于Spring Framework 5和Spring WebFlux框架，支持响应式编程模型，具有高性能和非阻塞IO的特性。</p>
                        <ul class="space-y-2">
                            <li><strong>响应式API：</strong> Spring Cloud Gateway提供了响应式的API，如<code>RouterFunction</code>和<code>HandlerFunction</code>，用于定义路由规则和请求处理逻辑。</li>
                            <li><strong>异步处理：</strong> 所有的请求处理都是基于事件驱动的异步处理模型，不会阻塞服务器线程，可以处理大量并发请求。</li>
                            <li><strong>函数式定义路由：</strong> Gateway使用<code>RouterFunction</code>来定义路由规则，通过Lambda表达式和函数式接口来声明路由条件和目标处理器。</li>
                        </ul>
                    </div>
                    <div>
                        <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1718972608786-5be55629-d7d3-45c5-95f3-66d56b2f12c5.png" alt="Gateway Reactive Model" class="rounded-lg shadow-md w-full h-auto">
                    </div>
                </div>
            </div>

            <!-- Core Components -->
            <div class="prose max-w-none mt-12">
                <h3 class="text-2xl mb-4">核心组件</h3>
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <h4 class="text-xl mb-3">RouterFunction</h4>
                        <p><code>RouterFunction</code>是定义路由规则的核心接口，它允许开发人员基于请求的路径、请求方法、请求头等条件来定义路由规则。</p>
                        <div class="code-block mt-4">
                            <pre><code>@Bean
public RouterFunction&lt;ServerResponse&gt; route() {
    return RouterFunctions.route()
            .path("/api", builder -> builder
                    .GET("/customers", request -> ServerResponse.ok().build())
                    .POST("/customers", request -> ServerResponse.created(...).build()))
            .build();
}</code></pre>
                        </div>
                    </div>
                    <div>
                        <h4 class="text-xl mb-3">HandlerFunction</h4>
                        <p><code>HandlerFunction</code>定义了实际的请求处理逻辑，例如向客户端发送响应或将请求转发给下游服务。</p>
                        <div class="code-block mt-4">
                            <pre><code>HandlerFunction&lt;ServerResponse&gt; handleGetCustomers = 
    request -> ServerResponse.ok().build();</code></pre>
                        </div>
                        <h4 class="text-xl mt-6 mb-3">Filter（过滤器）</h4>
                        <p>过滤器是Gateway中的重要组件，用于在请求被路由之前或之后对请求进行修改或处理。Gateway提供了许多内置的过滤器，同时也支持自定义过滤器来实现特定的业务逻辑处理。</p>
                    </div>
                </div>
            </div>

            <!-- Working Principle -->
            <div class="prose max-w-none mt-12">
                <h3 class="text-2xl mb-4">工作原理</h3>
                <div class="grid md:grid-cols-2 gap-8">
                    <div>
                        <ol class="list-decimal pl-6 space-y-2">
                            <li><strong>基于WebFlux的异步处理：</strong> Spring Cloud Gateway利用WebFlux框架的非阻塞IO处理能力，通过少量线程处理大量并发请求，实现高吞吐量的网关服务。</li>
                            <li><strong>路由规则匹配：</strong> Gateway根据配置的路由规则（Route）和路由断言器（Predicate），匹配请求的URL、请求头、参数等条件，确定请求的目标服务。</li>
                            <li><strong>过滤器链：</strong> 请求经过一系列的过滤器（Filter）链，每个过滤器执行特定的处理逻辑，如添加请求头、记录日志、修改请求体等。</li>
                            <li><strong>Handler处理：</strong> 经过过滤器链处理后，请求进入Handler处理阶段，Handler将请求转发到目标服务，并将服务的响应返回给客户端。</li>
                            <li><strong>断路器机制：</strong> Gateway集成了Hystrix断路器，当后端服务出现故障或超时时，可以通过断路器快速返回预设的响应，避免客户端长时间等待。</li>
                            <li><strong>限流和监控：</strong> Gateway支持基于请求频率、请求路径等条件进行限流，同时集成了Spring Boot Actuator和Micrometer，可以方便地监控和统计服务的运行状态和性能指标。</li>
                        </ol>
                    </div>
                    <div>
                        <div class="bg-white p-6 rounded-lg shadow-md">
                            <div id="gateway-flow" class="mermaid">
                                graph TD
                                A[客户端请求] --> B{路由匹配}
                                B -->|匹配成功| C[Pre过滤器]
                                C --> D[路由转发]
                                D --> E[Post过滤器]
                                E --> F[响应客户端]
                                B -->|匹配失败| G[返回404]
                                C -->|发生错误| H[Error过滤器]
                                D -->|发生错误| H
                                E -->|发生错误| H
                            </div>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Routing & Load Balancing -->
            <div class="prose max-w-none mt-12">
                <h3 class="text-2xl mb-4">路由与负载均衡</h3>
                <p>Spring Cloud Gateway在实现路由与负载均衡时，结合了Spring Framework 5和Spring WebFlux的响应式编程模型，提供了灵活而强大的路由和负载均衡机制。</p>
                
                <div class="filter-type">
                    <h4 class="text-xl mb-3">路由</h4>
                    <p>Spring Cloud Gateway通过路由定义来映射请求到后端服务。每个路由都包含一个目标URI、一组断言和一组过滤器。</p>
                    <p>目标URI指定了请求应该转发到的后端服务的位置。它可以是一个静态的URI，也可以包含动态的占位符。路由断言用于匹配传入的HTTP请求，以确定是否应该将请求路由到目标URI。</p>
                </div>

                <div class="filter-type">
                    <h4 class="text-xl mb-3">负载均衡</h4>
                    <p>Spring Cloud Gateway集成了Spring Cloud LoadBalancer来实现负载均衡。它支持以下几种负载均衡算法：</p>
                    <ul class="space-y-2">
                        <li><strong>Round Robin（轮询）：</strong> 按顺序将请求分配给每个服务实例。</li>
                        <li><strong>Weighted Response Time（加权响应时间）：</strong> 根据每个实例的平均响应时间和权重来动态调整负载均衡。</li>
                        <li><strong>Retry（重试）：</strong> 在一定时间内，如果请求失败，则将请求重定向到另一个服务实例。</li>
                    </ul>
                    <div class="code-block mt-4">
                        <pre><code>spring:
  cloud:
    gateway:
      routes:
        - id: myservice-route
          uri: lb://myservice
          predicates:
            - Path=/myservice/**
          filters:
            - StripPrefix=1</code></pre>
                    </div>
                </div>
            </div>
        </section>

        <!-- Comparison Section -->
        <section class="mb-16">
            <div class="prose max-w-none">
                <h2 class="text-3xl mb-6 flex items-center">
                    <span class="icon-circle bg-yellow-100 text-yellow-600 mr-4"><i class="fas fa-balance-scale"></i></span>
                    Zuul与Gateway的优缺点比较
                </h2>
                
                <div class="grid md:grid-cols-2 gap-8">
                    <!-- Zuul Pros & Cons -->
                    <div class="card bg-white p-6 rounded-lg shadow-md">
                        <h3 class="text-2xl mb-4 text-center">Netflix Zuul</h3>
                        <div class="mb-6">
                            <h4 class="text-xl font-semibold mb-3 text-green-600">优点</h4>
                            <ul class="space-y-2">
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                    <span>成熟稳定，经过了长时间的生产环境验证</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                    <span>功能丰富，具有路由、过滤、负载均衡等多种功能</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                    <span>易于与Eureka、Ribbon等Spring Cloud组件集成</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                    <span>由Netflix维护和支持，社区活跃</span>
                                </li>
                            </ul>
                        </div>
                        <div>
                            <h4 class="text-xl font-semibold mb-3 text-red-600">缺点</h4>
                            <ul class="space-y-2">
                                <li class="flex items-start">
                                    <i class="fas fa-times-circle text-red-500 mt-1 mr-2"></i>
                                    <span>Zuul 1.x 基于阻塞I/O，性能有限，不适合高并发场景</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-times-circle text-red-500 mt-1 mr-2"></i>
                                    <span>扩展性差，复杂的定制需求不易实现</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-times-circle text-red-500 mt-1 mr-2"></i>
                                    <span>Zuul 1.x 的每个过滤器都是同步执行的，一个过滤器执行慢会影响整体性能</span>
                                </li>
                            </ul>
                        </div>
                    </div>
                    
                    <!-- Gateway Pros & Cons -->
                    <div class="card bg-white p-6 rounded-lg shadow-md">
                        <h3 class="text-2xl mb-4 text-center">Spring Cloud Gateway</h3>
                        <div class="mb-6">
                            <h4 class="text-xl font-semibold mb-3 text-green-600">优点</h4>
                            <ul class="space-y-2">
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                    <span>基于响应式编程模型，性能优越，支持高并发</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                    <span>灵活的过滤器机制，支持全局和路由级别的过滤器配置</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                    <span>易于定制和扩展，满足复杂的定制需求</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-2"></i>
                                    <span>与Spring Cloud组件集成紧密</span>
                                </li>
                            </ul>
                        </div>
                        <div>
                            <h4 class="text-xl font-semibold mb-3 text-red-600">缺点</h4>
                            <ul class="space-y-2">
                                <li class="flex items-start">
                                    <i class="fas fa-times-circle text-red-500 mt-1 mr-2"></i>
                                    <span>相对较新，可能存在一些稳定性和成熟度方面的问题</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-times-circle text-red-500 mt-1 mr-2"></i>
                                    <span>基于响应式编程，学习曲线较陡</span>
                                </li>
                            </ul>
                        </div>
                    </div>
                </div>

                <!-- IO Model Comparison -->
                <div class="mt-12">
                    <h3 class="text-2xl mb-6">IO模型比较</h3>
                    <div class="grid md:grid-cols-2 gap-8">
                        <div>
                            <h4 class="text-xl mb-4">Zuul IO模型</h4>
                            <img src="https://cdn.nlark.com/yuque/0/2023/png/21449790/1677115400537-3473f627-116e-4617-9b86-af6f7a7fffdc.png" alt="Zuul IO Model" class="rounded-lg shadow-md w-full h-auto">
                            <p class="mt-4 text-sm text-gray-600">Zuul 1.x 基于Servlet模型，采用同步阻塞IO，每个请求需要一个线程来处理，不适合高并发场景。</p>
                        </div>
                        <div>
                            <h4 class="text-xl mb-4">Gateway IO模型</h4>
                            <img src="https://cdn.nlark.com/yuque/0/2023/png/21449790/1677115443275-9657f967-6d34-4084-ad4b-33353eee963b.png" alt="Gateway IO Model" class="rounded-lg shadow-md w-full h-auto">
                            <p class="mt-4 text-sm text-gray-600">Spring Cloud Gateway基于Netty和WebFlux，采用异步非阻塞IO，少量线程即可处理大量并发请求，适合高并发场景。</p>
                        </div>
                    </div>
                </div>

                <!-- Feature Comparison Table -->
                <div class="mt-12">
                    <h3 class="text-2xl mb-6">功能特性对比</h3>
                    <div class="overflow-x-auto">
                        <table class="comparison-table">
                            <thead>
                                <tr>
                                    <th>特性</th>
                                    <th>Zuul</th>
                                    <th>Spring Cloud Gateway</th>
                                </tr>
                            </thead>
                            <tbody>
                                <tr>
                                    <td>编程模型</td>
                                    <td>同步阻塞(Servlet)</td>
                                    <td>异步非阻塞(WebFlux)</td>
                                </tr>
                                <tr>
                                    <td>性能</td>
                                    <td>较低(每个请求一个线程)</td>
                                    <td>高(少量线程处理大量请求)</td>
                                </tr>
                                <tr>
                                    <td>扩展性</td>
                                    <td>一般</td>
                                    <td>优秀</td>
                                </tr>
                                <tr>
                                    <td>社区支持</td>
                                    <td>Netflix(维护中)</td>
                                    <td>Spring官方(活跃)</td>
                                </tr>
                                <tr>
                                    <td>学习曲线</td>
                                    <td>较低</td>
                                    <td>较高(响应式编程)</td>
                                </tr>
                                <tr>
                                    <td>适用场景</td>
                                    <td>中小型项目</td>
                                    <td>高并发、云原生项目</td>
                                </tr>
                            </tbody>
                        </table>
                    </div>
                </div>
            </div>
        </section>

        <!-- Conclusion -->
        <section class="mb-16">
            <div class="prose max-w-none">
                <h2 class="text-3xl mb-6">总结与选择建议</h2>
                <div class="card bg-white p-8 rounded-lg shadow-md">
                    <div class="feature-item">
                        <div class="icon-circle bg-blue-100 text-blue-600">
                            <i class="fas fa-lightbulb"></i>
                        </div>
                        <div class="feature-content">
                            <h3 class="text-xl font-semibold mb-2">选择Zuul的情况</h3>
                            <p>如果你的项目已经使用Spring Cloud Netflix组件，并且不需要处理极高的并发量，Zuul是一个稳定可靠的选择。它对开发人员的要求较低，上手快，适合中小型项目。</p>
                        </div>
                    </div>
                    <div class="feature-item">
                        <div class="icon-circle bg-green-100 text-green-600">
                            <i class="fas fa-rocket"></i>
                        </div>
                        <div class="feature-content">
                            <h3 class="text-xl font-semibold mb-2">选择Gateway的情况</h3>
                            <p>如果你需要构建高性能、高并发的微服务网关，或者项目已经采用响应式编程模型，Spring Cloud Gateway是更好的选择。它更适合云原生应用和大规模分布式系统。</p>
                        </div>
                    </div>
                    <div class="feature-item">
                        <div class="icon-circle bg-purple-100 text-purple-600">
                            <i class="fas fa-chart-line"></i>
                        </div>
                        <div class="feature-content">
                            <h3 class="text-xl font-semibold mb-2">未来趋势</h3>
                            <p>随着云原生和响应式编程的普及，Spring Cloud Gateway代表了API网关的未来发展方向。对于新项目，特别是高性能要求的项目，建议优先考虑Spring Cloud Gateway。</p>
                        </div>
                    </div>
                </div>
            </div>
        </section>
    </main>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-8">
        <div class="container mx-auto px-6 max-w-6xl">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-semibold">技术小馆</h3>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-gray-300 hover:text-white transition-colors duration-300">
                        <i class="fas fa-external-link-alt mr-2"></i>技术小馆地址
                    </a>
                </div>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```